package common

import (
	"strings"
	"unsafe"
)

// ArrayT 泛型约束，支持的数组元素类型
type ArrayT interface {
	byte | int8 | int16 | int32 | int64 | int | uint16 | uint32 | uint64 | uint | string
}

// StringToUint64Array 将字符串按分隔符转换为 uint64 数组。
func StringToUint64Array(str string, sub string) []uint64 {
	if str == "0" || str == "" {
		return make([]uint64, 0)
	}
	str = strings.ReplaceAll(str, " ", "")
	arr := strings.Split(str, sub)
	result := make([]uint64, len(arr))
	for i, v := range arr {
		result[i], _ = NewString(v).ToUint64()
	}
	return result
}

// StringToIntArray 将字符串按分隔符转换为 int 数组。
func StringToIntArray(str string, sub string) []int {
	if str == "0" || str == "" {
		return make([]int, 0)
	}
	str = strings.ReplaceAll(str, " ", "")
	arr := strings.Split(str, sub)
	result := make([]int, len(arr))
	for i, v := range arr {
		result[i], _ = NewString(v).ToInt()
	}
	return result
}

// StringToInt32Array 将字符串按分隔符转换为 int32 数组。
func StringToInt32Array(str string, sub string) []int32 {
	if str == "0" || str == "" {
		return make([]int32, 0)
	}
	str = strings.ReplaceAll(str, " ", "")
	arr := strings.Split(str, sub)
	result := make([]int32, len(arr))
	for i, v := range arr {
		tmp, _ := NewString(v).ToInt()
		result[i] = int32(tmp)
	}
	return result
}

// IntArrayToString 将数组转换为字符串，元素之间用指定分隔符连接。
func IntArrayToString[T ArrayT](arr []T, sub string) string {
	sb := NewStringBuilder()
	for i, v := range arr {
		if i != 0 {
			sb.Append(sub)
		}
		sb.Append(NewStringAny(v).ToString())
	}
	return sb.ToString()
}

// ArrayIndexof 在数组中查找指定值，返回索引，-1 表示未找到。
func ArrayIndexof[T ArrayT](array []T, v T) int {
	for i, m := range array {
		if m == v {
			return i
		}
	}
	return -1
}

// ArraySelectArray 判断 arr2 中的任意元素是否存在于 arr1 中。
func ArraySelectArray[T ArrayT](arr1, arr2 []T) bool {
	for i := range arr2 {
		if ArrayIndexof(arr1, arr2[i]) >= 0 {
			return true
		}
	}
	return false
}

// StringToBytes 将字符串转换为字节数组。
func StringToBytes(s string) []byte {
	return unsafe.Slice(unsafe.StringData(s), len(s))
}

// BytesToString 将字节数组转换为字符串。
func BytesToString(b []byte) string {
	return unsafe.String(&b[0], len(b))
}
